Attaching services to commanding elements

ABSTRACT

A commanding system for a computer. An input sequence can be received from an input device, and the commanding system can be used to connect the input to an associated action. Commanding can be provided by a plurality of nodes that represent elements of control and application levels. The nodes can be arranged in a hierarchical structure, and each node can include a table of bindings. A service can be attached to one or more of the nodes at run-time to provide additional commanding functionality. For example, a service can modify or supplement the binding entries provided in the table of bindings associated with a given node.

TECHNICAL FIELD

The present invention relates to commanding for a computer system and, more particularly, to attaching services to commanding elements.

BACKGROUND

A computer system typically includes a commanding system that allows a user's input to the computer to be connected to an action performed by the computer in response to the input. One example of commanding is the connection of the input keystroke “ctrl-c” to the action of copying of the selected material to the clipboard of the computer. An existing system that handles commanding is the Microsoft Foundation Class (MFC) Library. Commanding systems such as the MFC Library are implemented on an application-by-application basis. In other words, in existing computer systems, commanding is handled by each individual application.

An application is a program designed to assist a user of a computer system in the performance of a specific task. One example of an application is a word processing application, such as the WordPad application provided as an accessory application to various versions of the WINDOWS® brand operating systems, which were developed and distributed by Microsoft Corporation of Redmond, Wash. An application is created by translating (i.e., compiling) high-level object code, such as source code, into a lower-level code such as machine language (i.e., an executable) that can be run by the computer system.

Since, as noted above, commanding in existing computer systems is implemented as part of each application, it can be difficult to modify the commanding for a given application. For example, to modify the commanding for an application, it is necessary to modify the source code for the application and then to recompile the application into executable form for the modifications to commanding to take effect. Therefore, no easy method exists for modifying the commanding for a given application.

SUMMARY

The present invention relates to commanding for a computer system and, more particularly, to attaching services to commanding elements. A commanding system for a computer is configured to include at least one commanding node, implemented at the application level or at the control level. The commanding node can include commanding information that allows input to the computer system to be connected to an associated action. In addition, a service can be attached to the commanding node, the service providing additional commanding functionality.

One aspect of the invention is a commanding system for a computer. The commanding system includes a memory storing an input module that accepts input from a device in communication with the computer, a commanding node having a table of bindings that connect the input to associated action, each binding in the table of bindings including a command binding and associated command handler, and a service having a table of service bindings, each service binding in the table of service bindings including a command binding and associated command handler. The commanding system also includes a processor in data communication with the memory, the processor programmed to: attach the service to the commanding node; receive the input from the input module; pass the input to the commanding node, the commanding node looking up a matching command binding associated with the input in the table of bindings; pass the input to the service, the service looking up the matching command binding associated with the input in the table of service bindings; and invoke a command handler associated with the matching command binding if the matching binding is found in either the table of bindings or the table of service bindings.

Another aspect of the invention is a computer readable medium having data structure stored thereon for use in commanding within a computing environment. The data structure includes a first binding table for a first commanding node, the first binding table including a plurality of first bindings, each binding of the first bindings including a command binding, a command, and a handler. The data structure also includes a service binding table for a service attached to the commanding node, the service binding table including a plurality of service bindings, each binding of the service bindings including a command binding, a command, and a handler.

Yet another aspect of the invention is a method for commanding a computer system, including: receiving input from a user of the computer system; passing the input to a commanding node; looking up a matching binding associated with the input in a table of bindings; passing the input to a service coupled to the commanding node; looking up the matching binding associated with the input in a table of service bindings; and invoking a handler associated with the input.

BRIEF DESCRIPTION OF THE DRAWINGS

Reference will now be made to the accompanying drawings, which are not necessarily drawn to scale, and wherein:

FIG. 1 illustrates an example general purpose computing system according to one embodiment of the present invention;

FIG. 2 illustrates an example computing environment of the computer system of FIG. 1;

FIG. 3 illustrates an example operating environment for the computer system of FIG. 2;

FIG. 4 illustrates an example hierarchical tree according to one embodiment of the present invention;

FIG. 5 illustrates an example binding table including a plurality of binding elements according to one embodiment of the present invention;

FIG. 6 illustrates an example flow diagram for implementing commanding according to one embodiment of the present invention;

FIG. 7 illustrates another example flow diagram for implementing commanding according to one embodiment of the present invention;

FIG. 8 illustrates another example hierarchical tree according to an embodiment of the present invention; and

FIG. 9 illustrates an example flow diagram implementing commanding including services according to an embodiment of the present invention.

DETAILED DESCRIPTION

The present invention will now be described more fully hereinafter with reference to the accompanying drawings, in which embodiments of the invention are shown. This invention may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the invention to those skilled in the art. Like numbers refer to like elements throughout.

The present invention relates to commanding for a computer system and, more particularly, to attaching services to commanding elements. A commanding system for a computer system allows input from a user to be connected to a specific action to be performed by the computer system. More specifically, commanding allows input sequences from input devices to be connected to semantic actions to be performed by the computer system. Commanding can be implemented at the control or application level, as described further below. Commanding can be broken into commanding nodes, each commanding node including commanding information that connects input to an action. The commanding information can be modified or supplemented by attaching a service to a particular commanding node, thereby enhancing commanding for the system.

Referring now to FIG. 1, an example computer system 100 is illustrated. The computer system 100 illustrated in FIG. 1 can take a variety of forms such as, for example, a desktop computer, a laptop computer, and a hand-held computer. In addition, although computer system 100 is illustrated, commanding as disclosed herein can be implemented in various alternative computer systems as well.

The system 100 includes a processor unit 102, a system memory 104, and a system bus 106 that couples various system components including the system memory 104 to the processor unit 100. The system bus 106 can be any of several types of bus structures including a memory bus, a peripheral bus and a local bus using any of a variety of bus architectures. The system memory includes read only memory (ROM) 108 and random access memory (RAM) 110. A basic input/output system 112 (BIOS), which contains basic routines that help transfer information between elements within the computer system 100, is stored in ROM 108.

The computer system 100 further includes a hard disk drive 112 for reading from and writing to a hard disk, a magnetic disk drive 114 for reading from or writing to a removable magnetic disk 116, and an optical disk drive 118 for reading from or writing to a removable optical disk 119 such as a CD ROM, DVD, or other optical media. The hard disk drive 112, magnetic disk drive 114, and optical disk drive 118 are connected to the system bus 106 by a hard disk drive interface 120, a magnetic disk drive interface 122, and an optical drive interface 124, respectively. The drives and their associated computer-readable media provide nonvolatile storage of computer readable instructions, data structures, programs, and other data for the computer system 100.

Although the example environment described herein can employ a hard disk 112, a removable magnetic disk 116, and a removable optical disk 119, other types of computer-readable media capable of storing data can be used in the example system 100. Examples of these other types of computer-readable mediums that can be used in the example operating environment include magnetic cassettes, flash memory cards, digital video disks, Bernoulli cartridges, random access memories (RAMs), and read only memories (ROMs).

A number of program modules can be stored on the hard disk 112, magnetic disk 116, optical disk 119, ROM 108, or RAM 110, including an operating system 126, one or more application programs 128, other program modules 130, and program data 132.

A user may enter commands and information into the computer system 100 through input devices such as, for example, a keyboard 134, mouse 136, or other pointing device. Examples of other input devices include a toolbar, menu, touch screen, microphone, joystick, game pad, pen, satellite dish, and scanner. These and other input devices are often connected to the processing unit 102 through a serial port interface 140 that is coupled to the system bus 106. Nevertheless, these input devices also may be connected by other interfaces, such as a parallel port, game port, or a universal serial bus (USB). An LCD display 142 or other type of display device is also connected to the system bus 106 via an interface, such as a video adapter 144. In addition to the display 142, computer systems can typically include other peripheral output devices (not shown), such as speakers and printers.

The computer system 100 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 146. The remote computer 146 may be a computer system, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer system 100. The network connections include a local area network (LAN) 148 and a wide area network (WAN) 150. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets, and the Internet.

When used in a LAN networking environment, the computer system 100 is connected to the local network 148 through a network interface or adapter 152. When used in a WAN networking environment, the computer system 100 typically includes a modem 154 or other means for establishing communications over the wide area network 150, such as the Internet. The modem 154, which can be internal or external, is connected to the system bus 106 via the serial port interface 140. In a networked environment, program modules depicted relative to the computer system 100, or portions thereof, may be stored in the remote memory storage device. It will be appreciated that the network connections shown are examples and other means of establishing a communications link between the computers may be used.

The embodiments described herein can be implemented as logical operations in a computing system. The logical operations can be implemented (1) as a sequence of computer implemented steps or program modules running on a computer system and (2) as interconnected logic or hardware modules running within the computing system. This implementation is a matter of choice dependent on the performance requirements of the specific computing system. Accordingly, the logical operations making up the embodiments described herein are referred to as operations, steps, or modules. It will be recognized by one of ordinary skill in the art that these operations, steps, and modules may be implemented in software, in firmware, in special purpose digital logic, and any combination thereof without deviating from the spirit and scope of the present invention as recited within the claims attached hereto. This software, firmware, or similar sequence of computer instructions may be encoded and stored upon computer readable storage medium and may also be encoded within a carrier-wave signal for transmission between computing devices.

Referring now to FIG. 2, an example computing environment for the computer system 100 is shown. The computer system 100 includes operating system level 126, which includes software that interfaces with the hardware components of the computer 100 and performs rudimentary tasks. At a higher level shown in FIG. 2, application level 128 of computer system 100 includes various applications designed to assist a user in performance of a specific task. A control level 220 (sometimes referred to as the user interface level) is logically positioned between the operating system level 126 and application level 128. The control level 220 includes software that manages various elements of a graphical user interface.

Referring now to FIG. 3, an example user interface 300 for an application is provided. The example user interface 300 includes various control elements that are implemented at the control level. For example, the user interface 300 includes focus window 305, panel 310, button 320, and text box 330. The panel 310 is displayed in the focus window 305, and button 320 and text box 330 are displayed in panel 310.

The user interface illustrated in FIG. 3 is one example user interface, and various modifications can be made. For example and without limitation, the interface shown in FIG. 3 can be a user interface for the WordPad application, which is provided as an accessory application to various versions of MICROSOFT® WINDOWS® operating systems. In the illustrated embodiment, the focus window 305 is the window in which the application and control elements are shown. The panel 310 is positioned within the focus window 305. Likewise, button 320 and text box 330 are provided within the panel 310. For example, as shown, the button 320 is a button on a toolbar of the WordPad application, and the text box 330 is the portion of the panel 310 where a user inputs text.

The features of the user interface 300 illustrated in FIG. 3 (i.e., focus window 305, panel 310, button 320, and text box 330) can be logically represented as nodes of a hierarchical tree. For example, referring now to FIG. 4, an embodiment of a tree 400 is illustrated. Each node of the tree 400 (e.g., nodes 405, 410, 420, and 430) corresponds to a feature of the user interface 300 shown in FIG. 3. Specifically, the nodes of the tree 400 correspond to the features of the user interface 300 as follows:

-   -   node 405 corresponds to focus window 305;     -   node 410 corresponds to panel 310;     -   node 420 corresponds to button 320; and     -   node 430 corresponds to text box 330.

The nodes of the tree 400 are arranged in a hierarchical structure to represent the arrangement of the underlying features. In the example embodiment set forth herein, node 405, which logically represents focus window 305, is the parent to all other nodes in the tree 400 because all other features of the user interface fall within the focus window 305. Likewise, node 410, representing panel 310, is a descendant of node 405 because the panel 310 falls within the focus window 305. Similarly, nodes 420 and 430 represent button 320 and text box 330 within panel 310, which are on the same hierarchical level and are both descendants of node 410.

Each node of tree 400, can, but need not, be associated with a binding table. Generally, a binding table is a lookup table including a plurality of binding entries that connect inputs to actions. As illustrated in FIG. 4, node 405 is associated with binding table 405 a. Likewise, nodes 410, 420, and 430 are associated with binding tables 410 a, 420 a, and 430 a, respectively.

An example binding table 500 is illustrated in FIG. 5. The binding table 500 includes a plurality of binding entries 510, 520, 530, 540, 550, 560, 570, and 580. More or fewer binding entries also can be provided. Generally, each example binding entry of binding table 500 provides information that allows an action to be connected to an input that invokes the action. More specifically, binding entry 510 includes a command binding 510 a, a command 510 b, and a command handler 510 c. The command binding 510 a represents the input sequence (e.g., “ctrl-c”) from an input device that is received by the computer system 100 and that is to be acted upon. The command 510 b is a label that identifies the raw intent of the input sequence (e.g., “copy”). The command handler 510 c is a pointer to a portion of code that is executed to implement the action that is to be performed based upon the input sequence.

For example, binding entry 540 shown in FIG. 5 is an entry in the binding table 500 for the “copy” command. The command binding 540 a for binding entry 540 is the input sequence, in the illustrated case the keystroke, “ctrl-c.” The command 540 b is the label describing the intent of the input sequence, “copy.” The command handler 540 c is the object that is executed to actually implement the intent of the user, copying of selected material to the clipboard.

In one example embodiment, pseudo-code for implementing each entry of the binding table is as follows. <CommandLink Command = copy key = “ctrl-c” invoke = copy_handler /> In this example “commandlink” structure, the “Command” defines the command (i.e., “copy,” 540 b), the key defines the command binding (“ctrl-c,” 540 a), and the invoke defines the command handler (i.e., “copy_handler,” 540 c). A series of these commandlinks can be listed to create a binding table.

Generally, an example of how commanding, or the connection of an input to action, is implemented is illustrated in FIG. 6. At operation 610, input is received from, for example, an input module of the computer system 100 configured to accept an input sequence from an input device. Next, at operation 620, the node receiving the input examines the binding table associated with the node to determine if the table includes a matching command binding. If a matching command binding is found, the command handler associated with the matching command binding is invoked at operation 640. Alternatively, if a matching command binding is not found in the node's binding table, control can be passed to operation 630, and the input is bubbled to the next higher node in tree 400, as described further below.

Referring again to FIGS. 3 and 4, as described above, when the user interface 300 receives an input sequence (e.g., from a user using an input device such as, for example, a keyboard or mouse), the binding table associated with that node that receives the input is traversed in an attempt to connect the input sequence to an action. In addition to traversing the binding table associated with the input, the input can also be forwarded to nodes in tree 400 that are parents and children to the node, and the binding tables associated with these parent and children nodes traversed as well in an attempt to connect the input sequence to an action.

In one possible embodiment, the input can be traversed through the tree 400 in two directions. Bubbling occurs when the tree 400 is traversed upward from a child to its parent, grandparent, etc. Conversely, tunneling occurs when the tree 400 is traversed downward from a parent to its child, grandchild, etc. As described further below, by bubbling and tunneling the input through nodes that are parents and children of the node that originally receives the input, additional and more flexible commanding functionality can be realized.

For example, referring again to FIGS. 3 and 4, assume that an input sequence is received at the text box 330 of the user interface 300. Node 430 in tree 400 represents the text box 330 implemented at the control level 220. When the input is received, the binding table 430 a associated with the node 430 is examined in an attempt to match the input to a command binding in the table 430 a. In addition, the input can be bubbled to the parent of node 430 in the tree 400, node 410, so that the binding table 410 a associated with node 410 can be examined in an attempt to identify a matching command binding in the table 410 a. Tunneling in the opposite direction can also be done if, for example, node 410 had a child node. In one possible embodiment, the input is tunneled down to a base node, and then bubbled up to the original node.

In some example embodiments, the input sequence can be bubbled through the parent nodes in the tree 400 regardless of whether or not a particular node has a matching command binding in its binding table. For example, an embodiment of this operational flow is illustrated in FIG. 7. At operation 710, the input sequence is received. Beginning at operation 720, the input is traversed through tree 400 (e.g., bubbled and/or tunneled). The operation 720 begins at the node that has received the input. At operation 730, the node is checked to determine whether the node has a binding table associated with it (not all nodes may be associated with a binding table, as noted below).

If the node does not have an associated binding table, control is passed back to operation 720 and the input is bubbled or tunneled to the next parent or child node in the tree. If the node does have an associated binding table, the binding table is traversed at operation 740 to determine if the binding table has a command binding that matches the input sequence. At operation 750, if a matching command binding is not found in the table, control is passed back to operation 720 and the input is bubbled or tunneled to the next node in the tree.

If a matching command binding is found in the table, control is passed to operation 760, where it is determined whether or not the matching command binding is enabled. Binding entries within a binding table can be enabled or disabled depending on various factors surrounding commanding for the node. For example and without limitation, if the computer system 100 is not connected to a printer, binding entries in the binding table associated with printing can be disabled because such an action is not possible. If the matching command binding is not enabled, control is passed back to operation 720 and the input is bubbled or tunneled to the next node in the tree.

Enabling of commands can be implemented in several manners. For example, each entry in the binding table can have an enabled property associated with it to indicate whether or not the entry is enabled. In another embodiment, an additional handler can be associated with each binding entry so that, if an input sequence matches a specific entry, the handler invokes a section of code that is used to determine whether or not the entry is enabled. In another embodiment, the command associated with a matching binding entry can be tunneled and bubbled separately, as described below, so that another binding entry in the same or a different binding table can determine whether or not the entry is enabled.

If the matching command binding is enabled, the tree can be traversed (i.e., tunneled and bubbled) at operation 770 using the matching command associated with the matching command binding. Specifically, the tree can be traversed and each binding table examined to determine if any element has a specific command handler for the matching command.

There can be a variety of reasons why it may be desirable to traverse the tree a second time with the matching command. For example, a binding entry in a given binding table may provide a matching command binding and command, but may not include a command handler associated with the matching command. In this case, the matching command can be tunneled and bubbled in an attempt to find a matching command handler in a parent or child node. In another example, while a matching command in a binding table of a node may include an associated command handler, it is possible that a parent or child of the element may include a different “action” or command handler for a matching command. For example, although a matching command and command handler may be found in a binding table of a node, the node's parent may indicate that the matching command is not enabled and therefore the matching command handler should not be invoked. In another example, a binding table may not have a command binding for a particular input sequence, but may have a command handler for the command associated with the input sequence. Consequently, by tunneling and bubbling the command, a particular command can possibly be handled by a binding entry that does not have a matching command binding. Therefore, additional commanding information can be ascertained by tunneling and bubbling the matching command.

Finally, once the tree has been traversed with the matching command, at operation 780 the command handler associated with the matching binding entry is invoked to cause the action associated with the input sequence.

With reference again to FIGS. 4, 5, and 7, an operational flow illustrating how a specific input is handled is as follows. Initially, a copy “ctrl-c” input is received from the keyboard (operation 710) to copy text selected in text box 330 (corresponding to node 430). Next, the tree 400 is traversed, starting at node 430 (operation 720). Because node 430 has a binding table (operation 730), the binding table 430 a is traversed to see if it has a matching command binding (operation 740).

Assuming that the binding table 430 a of node 430 is table 500 illustrated in FIG. 5, binding entry 540 provides a matching command binding 540 a (operation 750). Next, assuming the matching command binding 540 a is enabled (operation 760), the matching command 540 b associated with the matching command binding 540 a is traversed through the tree 400 (operation 770). Assuming that none of the parent or children nodes to node 430 provide otherwise, the command handler 540 c associated with the matching command 540 b is then invoked and the selected text is copied to the clipboard (operation 780).

In this manner, the various nodes in the tree 400, which all represent features that are implemented at the control level, can accept an input sequence and connect the input to an action using the associated binding table. If a matching command binding is not found, the input can be bubbled to the next higher node in the tree 400, and its binding table can be examined for a matching command binding. In other words, if a given node of the tree 400 does not include a matching binding, one of its parents may include a matching binding which will allow the input to be connected to its given action.

This extension of commanding to the control level can allow for individual control elements so that specific control elements can be configured to handle input sequences as desired. Therefore, because the nodes of the tree 400 logically represent control elements (e.g., control elements 310, 320, and 330) in the control level, commanding can be provided in both the application level as well as control level of the computer system 100, thereby providing greater flexibility in commanding.

If conflicting information is contained with a given binding table, the conflict can be resolved in a number of manners. For example, in one embodiment, conflicting binding entries in a binding table are resolved using a “last entry wins” rule. For example, if two binding entries in a table match an input sequence, the last entry in the table dictates how the input sequence is handled. Other methods can also be used to handle conflicts such as, for example, a “first entry wins” rule.

In an alternative embodiment, multiplexed events can also be associated with a given node in the tree 400. For example, a multiplexed event can be associated with a node to specify that a particular command handler is to handle all input sequences passed to the node regardless of the type of input sequence. For example, a multiplexed event can be used when several commands have similar handling logic. In this manner, a single command handler can handle all inputs passed to the node.

In other alternative embodiments, binding entries in a binding table may not specify all properties for particular bindings. For example, a particular control element or application element can include a binding entry indicating that the element understands a particular command (e.g., “copy”), but the entry may not provide additional information regarding, for example, an input sequence or command handler associated with the command. This additional information can be ascertained, for example, through tunneling and bubbling.

In yet another alternative embodiment, information associated with input sequences received by a focus element (i.e., the element of a user interface that is currently in used by a user, or 305 in FIG. 3) can be forwarded to other control elements or application elements if the focus element cannot understand a given input sequence. For example, if a scroll bar is currently the focus element, and the user provides an input sequence of “ctrl-c,” the nodes associated with the scroll bar may not be able to link the “copy” command associated with the input sequence to a specific action. However, the command can be “forwarded” to, for example, an adjacent node not in the direct lineage of the node which received the input. For example, this adjacent node can be associated with a text box that, while not a focus element, is currently open in the user interface. The copy command can be bubbled through the adjacent node's lineage and handled based on the commanding for the text box (i.e., the text box can include one or more bindings to handle the copy command). In this manner, commands that cannot be handled by the focus element may be handled by other control elements or application elements.

Although the example tree 400 and associated operational flow diagrams have been described with respect to a specific number of nodes in the tree 400, more or fewer nodes can also be provided depending on the number of control elements and application elements in a given user interface. In addition, not every node in a tree may include a binding table. For example, if a node receives an input sequence and does not have a binding table, the node can bubble and/or tunnel the input through the tree, and a parent or child can handle the input.

As previously noted, nodes in the tree 400 can correspond to elements in both the control level and the application level. In addition, although examples disclosed herein have focused on the copy command, the commanding systems and methods described herein can be configured to handle a variety of inputs from various input devices.

Additional details regarding alternative embodiments of the commanding systems described above can be found in U.S. patent application Ser. No. 10/___.___, Attorney Docket No. MS305610.01/60001.314US01, entitled “Extension of Commanding to Control Level;” U.S. patent application Ser. No. 10/___,___ Attorney Docket No. MS305612.01/60001.316US01, entitled “Providing Multiple Input Bindings Across Device Categories;” and U.S. patent application Ser. No. 10/___,___ , Attorney Docket No. MS305613.01/60001.317US01, entitled “Dynamically-Generated Commanding Interface,” all of which are filed on even date herewith and are hereby incorporated by reference in their entireties.

Referring now to FIG. 8, another example tree 800 is illustrated. The tree 800 is similar to tree 400 described above, except for the noted differences. Tree 800 includes nodes 805 and 810. Additional nodes can also be provided. As in tree 400, each node 805 and 810 represents an element of an application or control for the application. For example and without limitation, node 805 can represent a panel in a user interface (e.g., panel 310 of user interface 300), and node 810 can represent a button in the user interface (e.g., button 320), in a manner similar to that described above with respect to tree 400.

Each node 805 and 810 is associated with a binding table 805 a and 810 a, respectively, that has a plurality of binding entries. Further, the nodes 805 and 810 function in a manner similar to that described above with respect to the nodes of tree 400, in that once an input sequence is received at either node 805 or 810, the binding table associated with the node is traversed to identify a matching command binding. In addition, inputs can be bubbled and/or tunneled through the tree 800. For example, if an input sequence is received at node 810, the binding table 810 a is traversed in an attempt to identify a matching command binding, and the input sequence or matching command (depending on whether a matching command binding is located in binding tree 810 a) is bubbled up to node 805. At node 805, the binding table 805 a associated with node 805 is similarly traversed, and the results can be tunneled back to node 810.

However, node 810 in tree 800 differs from previously-described nodes of tree 400 in that node 810 has a service 850 “attached to” the node 810. In general, the service 850 enhances the commanding provided at node 810. For example, the service 850 is associated with a binding table 850 a that includes commanding information that can differ from or supplement the commanding information provided in binding table 810 a associated with node 810.

For example, in some embodiments the binding table 850 a includes binding entries for at least some of the same input sequences as those provide for in binding table 810 a, except that the binding entries in table 850 a provide modified or additional functionality not found in table 810 a. In other embodiments, the binding table 850 a includes additional binding entries for input sequences not provided in binding table 810 a. In both instances, the service 850 provides modified or supplemental commanding information beyond that included with node 810.

As noted above, the service 850 is “attached to” the node 810. In example embodiments, the service 850 is attached to the node 810 at “run-time,” or the time at which an application is executed or run. For example and without limitation, various elements represented by the nodes of the tree 800 are built in the memory 104 of the computer system 100 at the time an application is executed or run. At this time (i.e., run-time), the service 850 is attached to node 810 of the tree 800.

Because the service can be attached at run-time for the illustrated examples, the service need not be part of the executable application that is created by translating (i.e., compiling) source code for the application into the executable application that is in a form that the computer can execute. In addition, the service need not be part of any of the control elements, either. Therefore, because the attached service need not be part of the application or control elements, the commanding provided by the service can be modified without requiring the source code for either the application or control element to be modified and recompiled.

Referring now to FIG. 9, an example flow diagram for commanding including a service is provided. The example flow diagram begins at operation 905, when an application is executed or run on the computer system 100, and the various elements represented by the nodes of the tree 800 are built in memory 104. A service, such as service 850, is then attached to a node of the tree 800 at operation 907.

At operation 910, an input sequence is received at, for example, a node of the tree 800, such as node 810. At operation 920, the binding table 810 a associated with node 810 is traversed in an attempt to identify a matching command binding for the input sequence. Next, the input sequence is passed to the service 850 at operation 950.

The binding table 850 a associated with the service 850 is traversed at operation 960 to determine if table 850 a includes a matching command binding for to the input sequence. If it is determined at operation 960 that a matching command binding has been found in the binding table 850 a of the service 850, control is passed to operation 970 and the command handler associated with the matching command binding is invoked. Alternatively, if a matching command binding is not found, control is passed to operation 980, where the input sequence (or matching command if one has been found in the table 850 a) is bubbled and/or tunneled to a parent or child node as described above with respect to the flow diagram illustrated in FIG. 7.

As illustrated, a service such as service 850 modified and/or supplements commanding for a node such as node 810. For example, the attached service 850 modifies how commanding is handled by changing which action is connected to a given input sequence. For example, the binding table 810 a of node 810 can include a matching command binding and associated command handler for a given input sequence. However, the binding table 850 a of the service 850 can provide a different command handler to handle the same input sequence, thereby potentially changing how commanding is provided for a given input sequence.

For example and without limitation, one embodiment in which commanding is modified is with the keystroke “ctrl-c” input sequence. Assume that, when node 810 receives this input sequence, the binding table 810 a associated with node 810 includes a matching command binding that connects this input sequence to a command handler that invokes code to simply copy selected text to the clipboard. However, if a service such as service 850 is attached to the node 810, the service 850 can modify how the input sequence “ctrl-c” is handled. For example, the binding table 850 a for the service 850 can include a matching command binding that connects the “ctrl-c” input sequence to a different command handler that not only copies the selected text to the clipboard, but provides a smart clipboard that can retain multiple instances of copied material on the clipboard and only overwrite copied material on the clipboard once a certain number of instances of copies material are on the clipboard. In this manner, the service 850 can modify how commanding for a given input sequence (e.g., “ctrl-c”) is handled.

In other embodiments, instead of modifying commanding for a particular input, the service 850 can simply supplement commanding. For example and without limitation, the binding table 810 a for node 810 may include binding entries for a plurality of input sequences, except for an input sequence “ctrl-r” used to invoke right-justification of text in a textbox. However, a service such as service 850 can be attached to node 810, and binding table 850 a can include a binding entry with a matching command binding and command handler for the input sequence “ctrl-r.” In this manner, the service 850 can supplement how commanding is implemented for a given input sequence (e.g., “ctrl-r”).

In example embodiments, the service is invoked by the application at run-time, and can be attached to either an application element or a control element. For example, when an application executes a control element, the application can designate a service to attach to the control element.

If a conflict arises between a matching binding entry in an element's binding table and another matching entry in an attached service's binding table, the “last entry wins” rule described above. If this rule is employed, the binding entry in the binding table associated with the attached service is typically used because the binding entries in the binding table of the service is typically traversed after the entries in the binding table associated with the element.

In example embodiments, a service attached to a node need not understand the inner-workings of the element represented by the node in order for the service to enhance commanding. For example, if a particular node representing a text box receives a particular input, a service attached to that node need not understand how the text box works internally, but instead only needs to understand the input that is passed to it.

The various embodiments described above are provided by way of illustration only and should not be construed to limit the invention. Those skilled in the art will readily recognize various modifications and changes that may be made to the present invention without following the example embodiments and applications illustrated and described herein, and without departing from the true spirit and scope of the present invention, which is set forth in the following claims. 

1. A commanding system for a computer, comprising: a memory storing an input module that accepts input from a device in communication with the computer, a commanding node having a table of bindings that connect the input to associated action, each binding in the table of bindings including a command binding and associated command handler, and a service having a table of service bindings, each service binding in the table of service bindings including a command binding and associated command handler; and a processor in data communication with the memory, the processor programmed to: attach the service to the commanding node; receive the input from the input module; pass the input to the commanding node, the commanding node looking up a matching command binding associated with the input in the table of bindings; pass the input to the service, the service looking up the matching command binding associated with the input in the table of service bindings; and invoke a command handler associated with the matching command binding if the matching binding is found in either the table of bindings or the table of service bindings.
 2. The system of claim 1, wherein the processor is further programmed to attach the service to the commanding node at run-time.
 3. The system of claim 1, wherein the memory further comprises a second commanding node, and wherein the processor is further programmed to attach a second service to the second commanding node at run-time.
 4. The system of claim 1, wherein the table of service bindings includes binding entries not included in the table of bindings of the commanding node.
 5. The system of claim 1, wherein the table of service bindings includes binding entries that differ from binding entries included in the table of bindings of the commanding node.
 6. The system of claim 1, wherein the processor is further programmed such that, if the matching binding is found in the table of bindings of the command node, the command node passes the input to the service prior to invoking a command handler.
 7. The system of claim 1, wherein the memory further comprises a second commanding node including a second table of bindings, and wherein the processor is further programmed such that, if the matching binding is not found in the table of bindings of the commanding node, the input is passed to the second commanding node, wherein the second commanding node looks up the matching binding in the table of second bindings.
 8. The system of claim 7, wherein passing the input from the commanding element to the second commanding element is a bubble operation, and wherein the processor is programmed to perform additional bubble operations.
 9. The system of claim 1, wherein each binding entry in the table of bindings in the memory includes at least a command binding, a command, and a command handler.
 10. The system of claim 1, wherein the commanding node represents an element of a user interface that is implemented at a control level.
 11. A computer readable medium having data structure stored thereon for use in commanding within a computing environment, the data structure comprising: a first binding table for a first commanding node, the first binding table including a plurality of first bindings, each binding of the first bindings including a command binding, a command, and a handler; and a service binding table for a service attached to the commanding node, the service binding table including a plurality of service bindings, each binding of the service bindings including a command binding, a command, and a handler.
 12. The computer readable medium as defined in claim 11, further comprising a second binding table for a second commanding node, the second binding table including a plurality of second bindings, each binding of the second bindings including a command binding, a command, and a handler.
 13. The computer readable medium as defined in claim 12, wherein the first and second commanding nodes form a tree.
 14. The computer readable medium as defined in claim 13, wherein the tree is further formed by a plurality of additional nodes, each node of the plurality of additional nodes including a binding table with a plurality of bindings.
 15. The computer readable medium as defined in claim 14, wherein a service is attached to one node of the plurality of additional nodes.
 16. A method for commanding a computer system, comprising: receiving input from a user of the computer system; passing the input to a commanding node; looking up a matching binding associated with the input in a table of bindings; passing the input to a service coupled to the commanding node; looking up the matching binding associated with the input in a table of service bindings; and invoking a handler associated with the input.
 17. The method of claim 16, further comprising attaching the service to the commanding node.
 18. The method of claim 16, further comprising attaching the service to the commanding node at run-time.
 19. The method of claim 16, further comprising passing the input to a second commanding node.
 20. The method of claim 19, further comprising attaching a second service to the second commanding node. 